!pip install scikit-optimize
!pip install xgboost
!pip install ace_tools

Requirement already satisfied: scikit-optimize in /usr/local/lib/python3.11/dist-packages (0.10.2)
Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.11/dist-packages (from scikit-optimize) (1.5.1)
Requirement already satisfied: pyaml>=16.9 in /usr/local/lib/python3.11/dist-packages (from scikit-optimize) (25.7.0)
Requirement already satisfied: numpy>=1.20.3 in /usr/local/lib/python3.11/dist-packages (from scikit-optimize) (2.0.2)
Requirement already satisfied: scipy>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from scikit-optimize) (1.16.0)
Requirement already satisfied: scikit-learn>=1.0.0 in /usr/local/lib/python3.11/dist-packages (from scikit-optimize) (1.6.1)
Requirement already satisfied: packaging>=21.3 in /usr/local/lib/python3.11/dist-packages (from scikit-optimize) (25.0)
Requirement already satisfied: PyYAML in /usr/local/lib/python3.11/dist-packages (from pyaml>=16.9->scikit-optimize) (6.0.2)
Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=1.0.0->scikit-optimize) (3.6.0)
Requirement already satisfied: xgboost in /usr/local/lib/python3.11/dist-packages (3.0.2)
Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from xgboost) (2.0.2)
Requirement already satisfied: nvidia-nccl-cu12 in /usr/local/lib/python3.11/dist-packages (from xgboost) (2.21.5)
Requirement already satisfied: scipy in /usr/local/lib/python3.11/dist-packages (from xgboost) (1.16.0)
Collecting ace_tools
  Downloading ace_tools-0.0-py3-none-any.whl.metadata (300 bytes)
Downloading ace_tools-0.0-py3-none-any.whl (1.1 kB)
Installing collected packages: ace_tools
Successfully installed ace_tools-0.0

# Manipulación y análisis de datos
import numpy as np
import pandas as pd
import xgboost as xgb

# Visualización
import matplotlib.pyplot as plt
import seaborn as sns
import altair as alt

# Modelado y preprocesamiento
from sklearn.model_selection import train_test_split, StratifiedKFold
from sklearn.preprocessing import StandardScaler, LabelEncoder, MinMaxScaler, OneHotEncoder
from sklearn.pipeline import Pipeline

# Clasificadores
from sklearn.linear_model import LogisticRegression, LinearRegression, RidgeCV, LassoCV, Ridge, Lasso
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
from sklearn.compose import ColumnTransformer
from sklearn.svm import SVC, SVR
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor
from sklearn.neural_network import MLPClassifier, MLPRegressor
from sklearn.impute import SimpleImputer
from xgboost import XGBClassifier, XGBRegressor
from statsmodels.stats.outliers_influence import variance_inflation_factor

# Métricas
from sklearn.metrics import (
    classification_report, confusion_matrix,
    precision_score, recall_score, f1_score, roc_auc_score,
    RocCurveDisplay, mean_absolute_error, mean_squared_error
)
from statsmodels.stats.diagnostic import acorr_ljungbox

# Optimización de hiperparámetros
from skopt import BayesSearchCV
from skopt.space import Real, Integer, Categorical

# Redes Neuronales
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import SimpleRNN, LSTM, Dense
from tensorflow.keras.optimizers import Adam
from tensorflow.keras import Input

# Cargamos el primer dataset de velocidad del viento
url = "https://raw.githubusercontent.com/lihkir/Data/main/wind_speed/data_treino_dv_df_2000_2010.csv"
df = pd.read_csv(url)

# Mostrar una descripción rápida del dataframe
df.info()

# Mostrar las primeras filas del dataset
df.head()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 87693 entries, 0 to 87692
Data columns (total 13 columns):
 #   Column                                                 Non-Null Count  Dtype  
---  ------                                                 --------------  -----  
 0   HORA (UTC)                                             87693 non-null  object 
 1   VENTO, DIREï¿½ï¿½O HORARIA (gr) (ï¿½ (gr))             87693 non-null  float64
 2   VENTO, VELOCIDADE HORARIA (m/s)                        87693 non-null  float64
 3   UMIDADE REL. MAX. NA HORA ANT. (AUT) (%)               87693 non-null  float64
 4   UMIDADE REL. MIN. NA HORA ANT. (AUT) (%)               87693 non-null  float64
 5   TEMPERATURA Mï¿½XIMA NA HORA ANT. (AUT) (ï¿½C)         87693 non-null  float64
 6   TEMPERATURA Mï¿½NIMA NA HORA ANT. (AUT) (ï¿½C)         87693 non-null  float64
 7   UMIDADE RELATIVA DO AR, HORARIA (%)                    87693 non-null  float64
 8   PRESSAO ATMOSFERICA AO NIVEL DA ESTACAO, HORARIA (mB)  87693 non-null  float64
 9   PRECIPITAï¿½ï¿½O TOTAL, HORï¿½RIO (mm)                 87693 non-null  float64
 10  VENTO, RAJADA MAXIMA (m/s)                             87693 non-null  float64
 11  PRESSï¿½O ATMOSFERICA MAX.NA HORA ANT. (AUT) (mB)      87693 non-null  float64
 12  PRESSï¿½O ATMOSFERICA MIN. NA HORA ANT. (AUT) (mB)     87693 non-null  float64
dtypes: float64(12), object(1)
memory usage: 8.7+ MB

# Renombramos las variables para facilitar el análisis
df.columns = [
    'hora',
    'vento_direcao',
    'vento_velocidade',
    'umid_max_ant',
    'umid_min_ant',
    'temp_max_ant',
    'temp_min_ant',
    'umid_horaria',
    'pressao_horaria',
    'precipitacao',
    'vento_rajada_max',
    'pressao_max_ant',
    'pressao_min_ant'
]

# Conteo y porcentaje de datos faltantes
missing_count = df.isnull().sum()
missing_percent = (missing_count / len(df)) * 100
missing_data = pd.DataFrame({
    'missing_count': missing_count,
    'missing_percent': missing_percent
})
print(missing_data)

                  missing_count  missing_percent
hora                          0              0.0
vento_direcao                 0              0.0
vento_velocidade              0              0.0
umid_max_ant                  0              0.0
umid_min_ant                  0              0.0
temp_max_ant                  0              0.0
temp_min_ant                  0              0.0
umid_horaria                  0              0.0
pressao_horaria               0              0.0
precipitacao                  0              0.0
vento_rajada_max              0              0.0
pressao_max_ant               0              0.0
pressao_min_ant               0              0.0

# Resumen estadístico
df.describe()

# Separar las variables por tipo
catg_var = df.select_dtypes(include=['object']).columns
numbr_var = df.select_dtypes(include=np.number).columns.tolist()

# Mostrar los resultados
print("Variables categóricas:")
print(catg_var)
print("Variables numéricas:")
print(numbr_var)

Variables categóricas:
Index(['hora'], dtype='object')
Variables numéricas:
['vento_direcao', 'vento_velocidade', 'umid_max_ant', 'umid_min_ant', 'temp_max_ant', 'temp_min_ant', 'umid_horaria', 'pressao_horaria', 'precipitacao', 'vento_rajada_max', 'pressao_max_ant', 'pressao_min_ant']

# Seleccionar los colores a utilizar
colors = ['mediumorchid', 'darkorchid', 'darkslateblue',
          'mediumslateblue', 'indigo', 'darkmagenta',
          'orchid', 'plum']

for i, col in enumerate(numbr_var):
    # Mostrar estadísticas de simetría y distribución
    print(f'Column: {col}')
    print(f'Skew: {round(df[col].skew(), 2)}')
    print(f'Kurtosis: {round(df[col].kurtosis(), 2)}')

    # Crear gráficos
    plt.figure(figsize=(12, 4))

    # Histograma
    plt.subplot(1, 2, 1)
    df[col].hist(color=colors[i % len(colors)], alpha=0.7, edgecolor='black')
    plt.title(f'{col} - Historama')
    plt.grid(False)

    # Diagrama de Caja y Bigotes
    plt.subplot(1, 2, 2)
    sns.boxplot(x=df[col], color=colors[i % len(colors)])
    plt.title(f'{col} - Diagrama de Caja y Bigotes')
    plt.xlabel('')

    plt.tight_layout()
    plt.show()

Column: vento_direcao
Skew: -0.86
Kurtosis: -0.82

Column: vento_velocidade
Skew: 0.37
Kurtosis: -0.11

Column: umid_max_ant
Skew: -0.48
Kurtosis: -0.78

Column: umid_min_ant
Skew: -0.23
Kurtosis: -0.96

Column: temp_max_ant
Skew: 0.26
Kurtosis: -0.42

Column: temp_min_ant
Skew: 0.24
Kurtosis: -0.12

Column: umid_horaria
Skew: -0.35
Kurtosis: -0.89

Column: pressao_horaria
Skew: 6.18
Kurtosis: 179.64

Column: precipitacao
Skew: 17.65
Kurtosis: 476.4

Column: vento_rajada_max
Skew: 0.41
Kurtosis: 0.11

# Tomamos la variable hora como categórica
df['hora'] = df['hora'].astype(str)

# Gráfico de barras
plt.figure(figsize=(12, 6))
sns.countplot(x="hora", data=df, hue="hora", palette='magma', legend=False)
plt.title('Distribución de las Observaciones por Hora del Día', fontsize=14)
plt.xlabel('Hora del día', fontsize=12)
plt.ylabel('Número de observaciones', fontsize=12)
plt.xticks(rotation=45)
plt.grid(axis='y', alpha=0.3)
plt.tight_layout()
plt.show()

def scatter_regplot(data, strx, stry):
    sns.set(font_scale=1.2)
    fig, ax = plt.subplots(1, 2, figsize=(14, 6), sharey=True)

    # Scatterplot sin línea de tendencia
    sns.scatterplot(data=data, x=strx, y=stry, ax=ax[0], alpha=0.3, color='purple')
    ax[0].set_title(f'Scatterplot: {stry} vs {strx}')

    # Scatterplot con línea de regresión
    sns.regplot(data=data, x=strx, y=stry, ax=ax[1], scatter_kws={'alpha': 0.3}, line_kws={"color": "red"})
    ax[1].set_title(f'Regplot: {stry} vs {strx}')

    fig.suptitle(f'Relación entre {strx} y {stry}', fontsize=16)
    plt.tight_layout()
    plt.show()

# Variable dependiente
target = 'vento_velocidade'

# Variables independientes (todas las demás numéricas)
independent_vars = [col for col in numbr_var if col != target]

# Graficar
for col in independent_vars:
    scatter_regplot(df, col, target)

# Correlación de Pearson
plt.figure(figsize=(12, 8))
sns.heatmap(df[numbr_var].corr(), annot=True, fmt=".2f", cmap="RdPu", square=True)
plt.title("Matriz de Correlación - Pearson")
plt.show()

# Cargar los datos de entrenamiento y prueba
train_transaction = pd.read_csv('train_transaction.csv')
train_identity = pd.read_csv('train_identity.csv')
test_transaction = pd.read_csv('test_transaction.csv')
test_identity = pd.read_csv('test_identity.csv')

# Ver dimensiones
print("Dimensiones de train_transaction:", train_transaction.shape)
print("Dimensiones de train_identity:", train_identity.shape)
print("Dimensiones de test_transaction:", test_transaction.shape)
print("Dimensiones de test_identity:", test_identity.shape)

Dimensiones de train_transaction: (52143, 394)
Dimensiones de train_identity: (144233, 41)
Dimensiones de test_transaction: (53549, 393)
Dimensiones de test_identity: (141907, 41)

# Unir transacciones con función identidad
train_df = pd.merge(train_transaction, train_identity, on='TransactionID', how='left')
test_df = pd.merge(test_transaction, test_identity, on='TransactionID', how='left')

# Verificar el tamaño y primeras filas
print("Shape of train_df:", train_df.shape)
print("Shape of test_df:", test_df.shape)
train_df.head()

Shape of train_df: (52143, 434)
Shape of test_df: (53549, 433)

# Tipos de variables
cat_cols = train_df.select_dtypes(include=['object']).columns
num_cols = train_df.select_dtypes(include=np.number).columns

print("Variables categóricas:", len(cat_cols))
print("Variables numéricas:", len(num_cols))

Variables categóricas: 31
Variables numéricas: 403

# Conteo y porcentaje de valores faltantes
missing_count = train_df.isnull().sum()
missing_pct = (missing_count / len(train_df)) * 100
missing_data = pd.DataFrame({'Missing Count': missing_count, 'Missing %': missing_pct})
missing_data = missing_data[missing_data['Missing Count'] > 0].sort_values(by='Missing %', ascending=False)

print("Variables con datos faltantes:")
display(missing_data.head(10))

Variables con datos faltantes:

# Distribución de la variable objetivo
sns.countplot(x='isFraud', data=train_df)
plt.title("Distribución de Fraude (0 = No fraude, 1 = Fraude)")
plt.xlabel("isFraud")
plt.ylabel("Cantidad")
plt.show()

# Mostrar Porcentajes
fraud_rate = train_df['isFraud'].value_counts(normalize=True) * 100
print("Distribución porcentual:\n", fraud_rate)

Distribución porcentual:
 isFraud
0    97.301651
1     2.698349
Name: proportion, dtype: float64

# Comparar transacciones fraudulentas vs no fraudulentas por valor
plt.figure(figsize=(10, 5))
sns.histplot(data=train_df, x='TransactionAmt', hue='isFraud', bins=100, log_scale=True, element="step", stat="density", common_norm=False)
plt.title('Distribución de TransactionAmt por isFraud (log scale)')
plt.show()

# Agregar variables númericas adicionales
num_vars_to_plot = ['D1', 'C1']

for col in num_vars_to_plot:
    plt.figure(figsize=(10, 5))
    sns.kdeplot(data=train_df, x=col, hue='isFraud', fill=True, common_norm=False)
    plt.title(f'Distribución de {col} por isFraud')
    plt.show()

# Visualización de variables categóricas clave
cat_vars_to_plot = ['ProductCD', 'card4', 'card6', 'DeviceType']

for col in cat_vars_to_plot:
    plt.figure(figsize=(8, 4))
    sns.countplot(data=train_df, x=col, order=train_df[col].value_counts().index, hue='isFraud')
    plt.title(f'Distribución de {col} por isFraud')
    plt.xticks(rotation=45)
    plt.tight_layout()
    plt.show()

# Matriz de correlación con isFraud
# Filtrar columnas numéricas que existen en el dataset antes de elminiar las columnas
num_cols_after_drop = train_df.select_dtypes(include=np.number).columns.tolist()
num_vars_filtered = [col for col in num_cols_after_drop if train_df[col].isnull().mean() < 0.9]

# Creamos un sub-dataframe con las variables filtradas
corr_df = train_df[num_vars_filtered].copy()
corr_df['isFraud'] = train_df['isFraud']

# Correlación
correlation_matrix = corr_df.corr(numeric_only=True)
isFraud_corr = correlation_matrix['isFraud'].sort_values(key=abs, ascending=False)[1:20]

# Gráfico de las variables más correlacionadas con isFraud
plt.figure(figsize=(8, 10))
sns.barplot(x=isFraud_corr.values, y=isFraud_corr.index)
plt.title("Top 20 variables más correlacionadas con isFraud")
plt.show()

charts = {}
for i in ['id_12', 'id_15', 'id_16', 'id_28', 'id_29', 'id_30', 'id_31', 'id_32', 'id_33', 'id_34', 'id_35', 'id_36', 'id_37', 'id_38']:
    feature_count = train_df[i].value_counts(dropna=False).reset_index()
    feature_count.columns = [i, 'count']
    chart = alt.Chart(feature_count).mark_bar().encode(
                y=alt.Y(f"{i}:N", axis=alt.Axis(title=i)),
                x=alt.X('count:Q', axis=alt.Axis(title='Count')),
                tooltip=[i, 'count']
            ).properties(title=f"Counts of {i}", width=400)
    charts[i] = chart

chart_to_display = (charts['id_12'] | charts['id_15'] | charts['id_16']) & (charts['id_28'] | charts['id_29'] | charts['id_32']) & (charts['id_34'] | charts['id_35'] | charts['id_36']) & (charts['id_37'] | charts['id_38'])

chart_to_display.display()

charts = {}
for i in ['id_30', 'id_31', 'id_33', 'DeviceType', 'DeviceInfo']:
    feature_count = train_df[i].value_counts(dropna=False)[:40].reset_index()
    feature_count.columns = [i, 'count']
    chart = alt.Chart(feature_count).mark_bar().encode(
                x=alt.X(f"{i}:N", axis=alt.Axis(title=i)),
                y=alt.Y('count:Q', axis=alt.Axis(title='Count')),
                tooltip=[i, 'count']
            ).properties(title=f"Counts of {i}", width=800)
    charts[i] = chart

(charts['id_30'] & charts['id_31'] & charts['id_33'] & charts['DeviceType'] & charts['DeviceInfo']).display()

charts = {}
for i in ['ProductCD', 'card4', 'card6', 'M4', 'M1', 'M2', 'M3', 'M5', 'M6', 'M7', 'M8', 'M9']:
    feature_count = train_df[i].value_counts(dropna=False).reset_index()
    feature_count.columns = [i, 'count']
    chart = alt.Chart(feature_count).mark_bar().encode(
                y=alt.Y(f"{i}:N", axis=alt.Axis(title=i)),
                x=alt.X('count:Q', axis=alt.Axis(title='Count')),
                tooltip=[i, 'count']
            ).properties(title=f"Counts of {i}", width=400)
    charts[i] = chart

combined_charts = (charts['ProductCD'] | charts['card4']) & \
                  (charts['card6'] | charts['M4']) & \
                  (charts['M1'] | charts['M2']) & \
                  (charts['M3'] | charts['M5']) & \
                  (charts['M6'] | charts['M7']) & \
                  (charts['M8'] | charts['M9'])

combined_charts.display()

charts = {}
for i in ['P_emaildomain', 'R_emaildomain', 'card1', 'card2', 'card3',  'card5', 'addr1', 'addr2']:
    feature_count = train_df[i].value_counts(dropna=False).reset_index()[:40]
    feature_count.columns = [i, 'count']
    chart = alt.Chart(feature_count).mark_bar().encode(
                x=alt.X(f"{i}:N", axis=alt.Axis(title=i)),
                y=alt.Y('count:Q', axis=alt.Axis(title='Count')),
                tooltip=[i, 'count']
            ).properties(title=f"Counts of {i}", width=600)
    charts[i] = chart

((charts['P_emaildomain'] | charts['R_emaildomain']) & (charts['card1'] | charts['card2']) & (charts['card3'] | charts['card5']) & (charts['addr1'] | charts['addr2'])).display()

# Eliminar columnas con más de 95% de valores faltantes
cols_to_drop = train_df.columns[train_df.isnull().mean() > 0.95]
print("Columnas eliminadas:", len(cols_to_drop))
train_df.drop(columns=cols_to_drop, inplace=True)

Columnas eliminadas: 10

# Imputar valores númericos con la mediana
num_cols_clean = train_df.select_dtypes(include=np.number).columns
imputer = SimpleImputer(strategy='median')
train_df[num_cols_clean] = imputer.fit_transform(train_df[num_cols_clean])

# Imputar categóricas con 'missing' y codificar con LabelEncoder
cat_cols_clean = train_df.select_dtypes(include='object').columns
train_df[cat_cols_clean] = train_df[cat_cols_clean].fillna('missing')

le = LabelEncoder()
for col in cat_cols_clean:
    try:
        train_df[col] = le.fit_transform(train_df[col])
    except:
        train_df[col] = train_df[col].astype(str).apply(lambda x: hash(x) % 1000)

# Separar X e y
X = train_df.drop(columns=['isFraud'])
y = train_df['isFraud']

# Identify columns after previous steps
cat_cols = X.select_dtypes(include='object').columns
num_cols = X.select_dtypes(include=np.number).columns

# Impute numerical columns
imputer_num = SimpleImputer(strategy='median')
X[num_cols] = imputer_num.fit_transform(X[num_cols])

# Impute and encode categorical columns
# Check if there are any categorical columns left before proceeding
if len(cat_cols) > 0:
    imputer_cat = SimpleImputer(strategy='constant', fill_value='missing')
    X[cat_cols] = imputer_cat.fit_transform(X[cat_cols])

    onehot_encoder = OneHotEncoder(handle_unknown='ignore', sparse_output=False) # Use sparse_output instead of sparse
    X_cat_encoded = onehot_encoder.fit_transform(X[cat_cols])

    # Get feature names for encoded categorical columns
    cat_feature_names = onehot_encoder.get_feature_names_out(cat_cols)

    # Combine numerical and encoded categorical features
    X_num_df = X[num_cols].reset_index(drop=True)
    X_cat_df = pd.DataFrame(X_cat_encoded, columns=cat_feature_names).reset_index(drop=True)

    X_df = pd.concat([X_num_df, X_cat_df], axis=1)
else:
    # If no categorical columns, just use the numerical dataframe
    X_df = X[num_cols].copy().reset_index(drop=True)
    print("No categorical columns found for encoding.")


print("✅ Data preprocessed and encoded.")
print("Shape of X_df:", X_df.shape)
display(X_df.head())

No categorical columns found for encoding.
✅ Data preprocessed and encoded.
Shape of X_df: (52143, 423)

# Validación cruzada estratificada
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# Lista de resultados finales
tabla_resultados = []

# División en train/test con estratificación
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42)

# Pipeline
pipeline_knn = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', KNeighborsClassifier())
])

# Espacio de búsqueda bayesiana
search_space_knn = {
    'clf__n_neighbors': Integer(3, 25),
    'clf__p': Categorical([1, 2])
}

# BayesSearchCV
opt_knn = BayesSearchCV(
    estimator=pipeline_knn,
    search_spaces=search_space_knn,
    cv=cv,
    n_iter=10,
    scoring='roc_auc',
    n_jobs=-1,
    random_state=42,
    verbose=0
)

opt_knn.fit(X_train, y_train)
print("K-NN entrenado con los mejores hiperparámetros:")
print(opt_knn.best_params_)

K-NN entrenado con los mejores hiperparámetros:
OrderedDict([('clf__n_neighbors', 21), ('clf__p', 1)])

# Predicciones
y_pred = opt_knn.predict(X_test)
y_proba = opt_knn.predict_proba(X_test)[:, 1]

# Métricas
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
auc = roc_auc_score(y_test, y_proba)

print("Reporte de Clasificación:")
print(classification_report(y_test, y_pred))
print("AUC:", auc)

Reporte de Clasificación:
              precision    recall  f1-score   support

         0.0       0.97      1.00      0.99      3050
         1.0       1.00      0.02      0.23        85

    accuracy                           0.98      3155
   macro avg       0.99      0.51      0.52      3155
weighted avg       0.97      0.97      0.96      3155

AUC: 0.8201485053037608

# Matriz de confusión
knn_cm = confusion_matrix(y_test, y_pred)
f, ax = plt.subplots(figsize=(6, 4))
sns.heatmap(knn_cm, annot=True, linewidths=1, linecolor='black', fmt='g', cmap="BuPu", ax=ax)
plt.title('K-NN - Matriz de Confusión')
plt.xlabel('Y predicho')
plt.ylabel('Y real')
plt.tight_layout()
plt.show()

# Curva ROC
fig, ax = plt.subplots(figsize=(8, 6))
RocCurveDisplay.from_predictions(y_test, y_proba, ax=ax, name=f"K-NN (AUC = {auc:.3f})", color='darkblue')
ax.plot([0, 1], [0, 1], linestyle='--', color='gray', label='Azar (AUC = 0.5)')
ax.set_title("Curva ROC - K-NN", fontsize=16)
ax.set_xlabel("Tasa de Falsos Positivos", fontsize=12)
ax.set_ylabel("Tasa de Verdaderos Positivos", fontsize=12)
ax.legend(loc="lower right")
ax.grid(alpha=0.3)
plt.tight_layout()
plt.show()

# Pipeline
pipeline_lr = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', LogisticRegression(class_weight='balanced', max_iter=1000, solver='liblinear'))
])

# Espacio de búsqueda bayesiana
search_space_lr = {
    'clf__C': Real(1e-3, 100, prior='log-uniform'),
    'clf__penalty': Categorical(['l1', 'l2']),
}

# BayesSearchCV
opt_lr = BayesSearchCV(
    estimator=pipeline_lr,
    search_spaces=search_space_lr,
    cv=cv,
    n_iter=10,
    scoring='roc_auc',
    n_jobs=-1,
    random_state=42,
    verbose=0
)

opt_lr.fit(X_train, y_train)
print("Regresión Logística entrenada con los mejores hiperparámetros:")
print(opt_lr.best_params_)

# Predicciones
y_pred = opt_lr.predict(X_test)
y_proba = opt_lr.predict_proba(X_test)[:, 1]

# Métricas
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
auc = roc_auc_score(y_test, y_proba)

print("Reporte de Clasificación:")
print(classification_report(y_test, y_pred))
print("AUC:", auc)

Reporte de Clasificación:
              precision    recall  f1-score   support

         0.0       0.99      0.78      0.87      3500
         1.0       0.09      0.75      0.15        85

    accuracy                           0.77      3135
   macro avg       0.54      0.76      0.51      3135
weighted avg       0.97      0.77      0.85      3135

AUC: 0.8506576663452265

lr_cm = confusion_matrix(y_test, y_pred)
f, ax = plt.subplots(figsize=(6, 4))
sns.heatmap(lr_cm, annot=True, linewidths=1, linecolor='black', fmt='g', cmap="BuPu", ax=ax)
plt.title('Logistic Regression - Matriz de Confusión')
plt.xlabel('Y predicho')
plt.ylabel('Y real')
plt.show()

fig, ax = plt.subplots(figsize=(8, 6))
RocCurveDisplay.from_predictions(y_test, y_proba, ax=ax, name=f"LogReg (AUC = {auc:.3f})", color='royalblue')
ax.plot([0, 1], [0, 1], linestyle='--', color='gray', label='Azar (AUC = 0.5)')
ax.set_title("Curva ROC - Regresión Logística", fontsize=14)
ax.set_xlabel("Tasa de Falsos Positivos", fontsize=12)
ax.set_ylabel("Tasa de Verdaderos Positivos", fontsize=12)
ax.legend(loc="lower right", fontsize=10)
ax.grid(alpha=0.3)
plt.tight_layout()
plt.show()

# Pipeline
pipeline_nb = Pipeline([
    ('scaler', StandardScaler()),  # opcional para GaussianNB
    ('clf', GaussianNB())
])

# Entrenamiento
pipeline_nb.fit(X_train, y_train)

Pipeline(steps=[('scaler', StandardScaler()), ('clf', GaussianNB())])

Pipeline(steps=[('scaler', StandardScaler()), ('clf', GaussianNB())])

StandardScaler()

GaussianNB()

# Predicciones
y_pred = pipeline_nb.predict(X_test)
y_proba = pipeline_nb.predict_proba(X_test)[:, 1]

# Métricas
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
auc = roc_auc_score(y_test, y_proba)

print("Reporte de Clasificación:")
print(classification_report(y_test, y_pred))
print("AUC:", auc)

Reporte de Clasificación:
              precision    recall  f1-score   support

         0.0       1.00      0.20      0.33      3050
         1.0       0.03      0.96      0.06        85

    accuracy                           0.22      3135
   macro avg       0.51      0.58      0.20      3135
weighted avg       0.97      0.22      0.33      3135

AUC: 0.6073095467695275

# Matriz de confusión
nb_cm = confusion_matrix(y_test, y_pred)
f, ax = plt.subplots(figsize=(6, 4))
sns.heatmap(nb_cm, annot=True, linewidths=1, linecolor='black', fmt='g', cmap="BuPu", ax=ax)
plt.title('Naive Bayes - Matriz de Confusión')
plt.xlabel('Y predicho')
plt.ylabel('Y real')
plt.tight_layout()
plt.show()

# Curva ROC
fig, ax = plt.subplots(figsize=(8, 6))
RocCurveDisplay.from_predictions(y_test, y_proba, ax=ax, name=f"Naive Bayes (AUC = {auc:.3f})", color='lightcoral')
ax.plot([0, 1], [0, 1], linestyle='--', color='gray', label='Azar (AUC = 0.5)')
ax.set_title("Curva ROC - Naive Bayes", fontsize=14)
ax.set_xlabel("Tasa de Falsos Positivos", fontsize=12)
ax.set_ylabel("Tasa de Verdaderos Positivos", fontsize=12)
ax.legend(loc="lower right", fontsize=10)
ax.grid(alpha=0.3)
plt.tight_layout()
plt.show()

# Pipeline
pipeline_dt = Pipeline([
    ('clf', DecisionTreeClassifier(class_weight='balanced', random_state=42))
])

# Espacio de búsqueda
search_space_dt = {
    'clf__max_depth': Integer(3, 20),
    'clf__min_samples_split': Integer(2, 20),
    'clf__min_samples_leaf': Integer(1, 10)
}

# BayesSearchCV
opt_dt = BayesSearchCV(
    estimator=pipeline_dt,
    search_spaces=search_space_dt,
    cv=cv,
    n_iter=10,
    scoring='roc_auc',
    n_jobs=-1,
    random_state=42,
    verbose=0
)

opt_dt.fit(X_train, y_train)
print("Decision Tree entrenado con los mejores hiperparámetros:")
print(opt_dt.best_params_)

Decision Tree entrenado con los mejores hiperparámetros:
OrderedDict([('clf__max_depth', 10), ('clf__min_samples_leaf', 8), ('clf__min_samples_split', 19)])

# Predicciones
y_pred = opt_dt.predict(X_test)
y_proba = opt_dt.predict_proba(X_test)[:, 1]

# Métricas
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
auc = roc_auc_score(y_test, y_proba)

print("Reporte de Clasificación::")
print(classification_report(y_test, y_pred))
print("AUC:", auc)

Reporte de Clasificación::
              precision    recall  f1-score   support

         0.0       0.99      0.82      0.90      3050
         1.0       0.10      0.75      0.18        85

    accuracy                           0.82      3135
   macro avg       0.55      0.79      0.54      3135
weighted avg       0.97      0.82      0.88      3135

AUC: 0.8254811957569913

# Matriz de confusión
dt_cm = confusion_matrix(y_test, y_pred)
f, ax = plt.subplots(figsize=(6, 4))
sns.heatmap(dt_cm, annot=True, linewidths=1, linecolor='black', fmt='g', cmap="BuPu", ax=ax)
plt.title('Decision Tree - Matriz de Confusión')
plt.xlabel('Y predicho')
plt.ylabel('Y real')
plt.tight_layout()
plt.show()

# Curva ROC
fig, ax = plt.subplots(figsize=(8, 6))
RocCurveDisplay.from_predictions(y_test, y_proba, ax=ax, name=f"Decision Tree (AUC = {auc:.3f})", color='orange')
ax.plot([0, 1], [0, 1], linestyle='--', color='gray', label='Azar (AUC = 0.5)')
ax.set_title("Curva ROC - Decision Tree", fontsize=16)
ax.set_xlabel("Tasa de Falsos Positivos", fontsize=12)
ax.set_ylabel("Tasa de Verdaderos Positivos", fontsize=12)
ax.legend(loc="lower right", fontsize=10)
ax.grid(alpha=0.3)
plt.tight_layout()
plt.show()

# Pipeline
pipeline_rf = Pipeline([
    ('scaler', StandardScaler()),  # Aunque RF no lo necesita, lo incluimos para estructura uniforme
    ('clf', RandomForestClassifier(class_weight='balanced', random_state=42))
])

# Espacio de búsqueda bayesiana
search_space_rf = {
    'clf__n_estimators': Integer(100, 300),
    'clf__max_depth': Integer(5, 20),
    'clf__min_samples_split': Integer(2, 10),
}

# Validación cruzada estratificada
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# BayesSearchCV
opt_rf = BayesSearchCV(
    estimator=pipeline_rf,
    search_spaces=search_space_rf,
    n_iter=10,
    cv=cv,
    scoring='roc_auc',
    n_jobs=-1,
    random_state=42,
    verbose=0
)

opt_rf.fit(X_train, y_train)
print("Random Forest entrenado con los mejores hiperparámetros:")
print(opt_rf.best_params_)

Random Forest entrenado con los mejores hiperparámetros:
OrderedDict([('clf__max_depth', 19), ('clf__min_samples_split', 8), ('clf__n_estimators', 274)])

# Predicciones
y_pred = opt_rf.predict(X_test)
y_proba = opt_rf.predict_proba(X_test)[:, 1]

# Métricas
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
auc = roc_auc_score(y_test, y_proba)

print("Reporte de Classificación:")
print(classification_report(y_test, y_pred))
print("AUC:", auc)

Reporte de Classificación:
              precision    recall  f1-score   support

         0.0       0.98      1.00      0.99      3050
         1.0       0.92      0.42      0.58        85

    accuracy                           0.98      3135
   macro avg       0.95      0.71      0.79      3135
weighted avg       0.98      0.98      0.98      3135

AUC: 0.927760846017357

# Matriz de confusión
rf_cm = confusion_matrix(y_test, opt_rf.predict(X_test))
f, ax = plt.subplots(figsize=(6, 4))
sns.heatmap(rf_cm, annot=True, linewidths=1, linecolor='black', fmt='g', cmap="BuPu", ax=ax)
plt.title('Random Forest - Matriz de Confusión')
plt.xlabel('Y predicho')
plt.ylabel('Y real')
plt.show()

# Curva ROC
fig, ax = plt.subplots(figsize=(8, 6))

roc_display = RocCurveDisplay.from_predictions(
    y_test, y_proba,
    ax=ax,
    name=f"Random Forest (AUC = {auc:.3f})",
    color='palevioletred'
)

ax.plot([0, 1], [0, 1], linestyle='--', color='gray', label='Azar (AUC = 0.5)')
ax.set_title("Curva ROC - Random Forest", fontsize=14)
ax.set_xlabel("Tasa de Falsos Positivos (1 - Especificidad)", fontsize=12)
ax.set_ylabel("Tasa de Verdaderos Positivos (Sensibilidad)", fontsize=12)
ax.legend(loc="lower right", fontsize=10)
ax.grid(alpha=0.3)

plt.tight_layout()
plt.show()

# Pipeline
pipeline_xgb = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', XGBClassifier(
        use_label_encoder=False,
        eval_metric='logloss',
        scale_pos_weight=(y_train == 0).sum() / (y_train == 1).sum(),  # manejo del desbalance
        random_state=42
    ))
])

# Espacio de búsqueda
search_space_xgb = {
    'clf__n_estimators': Integer(100, 300),
    'clf__max_depth': Integer(3, 10),
    'clf__learning_rate': Real(0.01, 0.3, prior='log-uniform'),
    'clf__subsample': Real(0.6, 1.0),
    'clf__colsample_bytree': Real(0.6, 1.0),
}

# BayesSearchCV
opt_xgb = BayesSearchCV(
    estimator=pipeline_xgb,
    search_spaces=search_space_xgb,
    cv=cv,
    n_iter=10,
    scoring='roc_auc',
    n_jobs=-1,
    random_state=42,
    verbose=0
)

opt_xgb.fit(X_train, y_train)
print("XGBoost entrenado con los mejores hiperparámetros:")
print(opt_xgb.best_params_)

/usr/local/lib/python3.11/dist-packages/xgboost/core.py:158: UserWarning: [00:08:19] WARNING: /workspace/src/learner.cc:740: 
Parameters: { "use_label_encoder" } are not used.

  warnings.warn(smsg, UserWarning)

XGBoost entrenado con los mejores hiperparámetros:
OrderedDict([('clf__colsample_bytree', 0.7640415835413256), ('clf__learning_rate', 0.11883357504897696), ('clf__max_depth', 10), ('clf__n_estimators', 163), ('clf__subsample', 0.8680591793075738)])

# Predicciones
y_pred = opt_xgb.predict(X_test)
y_proba = opt_xgb.predict_proba(X_test)[:, 1]

# Métricas
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
auc = roc_auc_score(y_test, y_proba)

print("Reporte de Clasificación:")
print(classification_report(y_test, y_pred))
print("AUC:", auc)

Reporte de Clasificación:
              precision    recall  f1-score   support

         0.0       0.99      1.00      0.99      3050
         1.0       0.87      0.65      0.74        85

    accuracy                           0.99      3135
   macro avg       0.93      0.82      0.87      3135
weighted avg       0.99      0.99      0.99      3135

AUC: 0.9616162005785921

# Matriz de confusión
xgb_cm = confusion_matrix(y_test, y_pred)

f, ax = plt.subplots(figsize=(6, 4))
sns.heatmap(xgb_cm, annot=True, linewidths=1, linecolor='black', fmt='g', cmap="BuPu", ax=ax)
plt.title('XGBoost - Matriz de Confusión', fontsize=14)
plt.xlabel('Y predicho', fontsize=12)
plt.ylabel('Y real', fontsize=12)
plt.tight_layout()
plt.show()

fig, ax = plt.subplots(figsize=(8, 6))
RocCurveDisplay.from_predictions(y_test, y_proba, ax=ax, name=f"XGBoost (AUC = {auc:.3f})", color='teal')
ax.plot([0, 1], [0, 1], linestyle='--', color='gray', label='Azar (AUC = 0.5)')
ax.set_title("Curva ROC - XGBoost", fontsize=14)
ax.set_xlabel("Tasa de Falsos Positivos", fontsize=12)
ax.set_ylabel("Tasa de Verdaderos Positivos", fontsize=12)
ax.legend(loc="lower right", fontsize=10)
ax.grid(alpha=0.3)
plt.tight_layout()
plt.show()

## Pipeline
#pipeline_svm = Pipeline([
#    ('scaler', StandardScaler()),
#    ('clf', SVC(probability=True, class_weight='balanced'))
#])

## Espacio de búsqueda bayesiana
#search_space_svm = {
#    'clf__C': Real(1e-2, 100, prior='log-uniform'),
#    'clf__kernel': Categorical(['linear', 'rbf']),
#    'clf__gamma': Real(1e-4, 1.0, prior='log-uniform')
#}

## BayesSearchCV
#opt_svm = BayesSearchCV(
#    estimator=pipeline_svm,
#    search_spaces=search_space_svm,
#    cv=cv,
#    n_iter=10,
#    scoring='roc_auc',
#    n_jobs=-1,
#    random_state=42,
#    verbose=0
#)

#opt_svm.fit(X_train, y_train)
#print("SVM entrenado con los mejores hiperparámetros:")
#print(opt_svm.best_params_)

# Predicciones
# y_pred = opt_svm.predict(X_test)
# y_proba = opt_svm.predict_proba(X_test)[:, 1]

# Métricas
# precision = precision_score(y_test, y_pred)
# recall = recall_score(y_test, y_pred)
# f1 = f1_score(y_test, y_pred)
# auc = roc_auc_score(y_test, y_proba)

# print("Reporte de Clasificación:")
# print(classification_report(y_test, y_pred))
# print("AUC:", auc)

# Matriz de confusión
# svm_cm = confusion_matrix(y_test, y_pred)
# f, ax = plt.subplots(figsize=(6, 4))
# sns.heatmap(svm_cm, annot=True, linewidths=1, linecolor='black', fmt='g', cmap="BuPu", ax=ax)
# plt.title('SVM - Matriz de Confusión')
# plt.xlabel('Y predicho')
# plt.ylabel('Y real')
# plt.tight_layout()
# plt.show()

# Curva ROC
# fig, ax = plt.subplots(figsize=(8, 6))
# RocCurveDisplay.from_predictions(y_test, y_proba, ax=ax, name=f"SVM (AUC = {auc:.3f})", color='purple')
# ax.plot([0, 1], [0, 1], linestyle='--', color='gray', label='Azar (AUC = 0.5)')
# ax.set_title("Curva ROC - SVM", fontsize=14)
# ax.set_xlabel("Tasa de Falsos Positivos", fontsize=12)
# ax.set_ylabel("Tasa de Verdaderos Positivos", fontsize=12)
# ax.legend(loc="lower right", fontsize=10)
# ax.grid(alpha=0.3)
# plt.tight_layout()
# plt.show()

# Pipeline
pipeline_mlp = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', MLPClassifier(max_iter=300, random_state=42))
])

# Espacio de búsqueda bayesiana
search_space_mlp = {
    'clf__hidden_layer_sizes': Integer(50, 200),
    'clf__alpha': Real(1e-5, 1e-2, prior='log-uniform'),
    'clf__learning_rate_init': Real(1e-4, 1e-1, prior='log-uniform')
}

# BayesSearchCV
opt_mlp = BayesSearchCV(
    estimator=pipeline_mlp,
    search_spaces=search_space_mlp,
    cv=cv,
    n_iter=10,
    scoring='roc_auc',
    n_jobs=-1,
    random_state=42,
    verbose=0
)

opt_mlp.fit(X_train, y_train)
print("MLP entrenado con los mejores hiperparámetros:")
print(opt_mlp.best_params_)

MLP entrenado con los mejores hiperparámetros:
OrderedDict([('clf__alpha', 0.00042678505501429927), ('clf__hidden_layer_sizes', 188), ('clf__learning_rate_init', 0.003086029766693725)])

/usr/local/lib/python3.11/dist-packages/sklearn/neural_network/_multilayer_perceptron.py:698: UserWarning: Training interrupted by user.
  warnings.warn("Training interrupted by user.")

# Predicciones
y_pred = opt_mlp.predict(X_test)
y_proba = opt_mlp.predict_proba(X_test)[:, 1]

# Métricas
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
auc = roc_auc_score(y_test, y_proba)

print("Reporte de Clasificación:")
print(classification_report(y_test, y_pred))
print("AUC:", auc)

Reporte de Clasificación:
              precision    recall  f1-score   support

         0.0       0.98      0.99      0.99      3050
         1.0       0.51      0.45      0.48        25

    accuracy                           0.97      3135
   macro avg       0.75      0.72      0.73      3135
weighted avg       0.97      0.97      0.97      3135

AUC: 0.8270163934426229

# Matriz de confusión
mlp_cm = confusion_matrix(y_test, y_pred)
f, ax = plt.subplots(figsize=(6, 4))
sns.heatmap(mlp_cm, annot=True, linewidths=1, linecolor='black', fmt='g', cmap="BuPu", ax=ax)
plt.title('MLP - Matriz de Confusión')
plt.xlabel('Y predicho')
plt.ylabel('Y real')
plt.tight_layout()
plt.show()

# Curva ROC
fig, ax = plt.subplots(figsize=(8, 6))
RocCurveDisplay.from_predictions(y_test, y_proba, ax=ax, name=f"MLP (AUC = {auc:.3f})", color='lightseagreen')
ax.plot([0, 1], [0, 1], linestyle='--', color='gray', label='Azar (AUC = 0.5)')
ax.set_title("Curva ROC - MLP", fontsize=14)
ax.set_xlabel("Tasa de Falsos Positivos", fontsize=12)
ax.set_ylabel("Tasa de Verdaderos Positivos", fontsize=12)
ax.legend(loc="lower right", fontsize=10)
ax.grid(alpha=0.3)
plt.tight_layout()
plt.show()

# Create the results table with improved structure
results_data = {
    'Model': ['K-NN', 'Logistic Regression', 'Bayesian Classification', 'Decision Tree', 'Random Forest', 'XGBoost', 'Multilayer Perceptron'],
    'Accuracy': [0.97, 0.97, 0.22, 0.82, 0.98, 0.99, 0.97],
    'Precision_Class_0': [0.97, 0.99, 1.00, 0.99, 0.98, 0.99, 0.98],
    'Recall_Class_0': [1.00, 0.78, 0.20, 0.82, 1.00, 1.00, 0.99],
    'F1_Score_Class_0': [0.99, 0.87, 0.33, 0.90, 0.99, 0.99, 0.99],
    'Precision_Class_1': [1.00, 0.99, 0.05, 0.10, 0.92, 0.87, 0.51],
    'Recall_Class_1': [0.02, 0.75, 0.96, 0.75, 0.42, 0.65, 0.45],
    'F1_Score_Class_1': [0.05, 0.15, 0.06, 0.18, 0.58, 0.74, 0.48],
    'Macro_Avg_Precision': [0.99, 0.54, 0.51, 0.55, 0.95, 0.93, 0.75],
    'Macro_Avg_Recall': [0.51, 0.76, 0.58, 0.79, 0.71, 0.82, 0.72],
    'Macro_Avg_F1': [0.52, 0.51, 0.20, 0.54, 0.79, 0.87, 0.73],
    'Weighted_Avg_Precision': [0.97, 0.97, 0.97, 0.97, 0.98, 0.99, 0.97],
    'Weighted_Avg_Recall': [0.97, 0.97, 0.22, 0.82, 0.98, 0.99, 0.97],
    'Weighted_Avg_F1': [0.95, 0.85, 0.33, 0.88, 0.98, 0.99, 0.97],
    'AUC': [0.8201, 0.8506, 0.6073, 0.8254, 0.9277, 0.9615, 0.8278]
}

# Create DataFrame
df_results = pd.DataFrame(results_data)

# Sort by AUC (best performance indicator for imbalanced datasets)
df_results_sorted = df_results.sort_values('AUC', ascending=False).reset_index(drop=True)

# Add ranking column
df_results_sorted.insert(0, 'Rank', range(1, len(df_results_sorted) + 1))

# Create a more formatted display function
def display_enhanced_table(df):
    print("🎯 Comparación del desempeño de los modelos de Machine Learning")
    print("=" * 100)
    print(f"📊 Dataset: Class 0 (3,850 samples) | Class 1 (85 samples) | Imbalance Ratio: 45.3:1")
    print("=" * 100)

    # Display with better formatting
    pd.set_option('display.max_columns', None)
    pd.set_option('display.width', 1000)
    pd.set_option('display.float_format', '{:.3f}'.format)

    # Create a styled version
    styled_df = df.style.format({
        'Accuracy': '{:.3f}',
        'Precision_Class_0': '{:.3f}',
        'Recall_Class_0': '{:.3f}',
        'F1_Score_Class_0': '{:.3f}',
        'Precision_Class_1': '{:.3f}',
        'Recall_Class_1': '{:.3f}',
        'F1_Score_Class_1': '{:.3f}',
        'Macro_Avg_Precision': '{:.3f}',
        'Macro_Avg_Recall': '{:.3f}',
        'Macro_Avg_F1': '{:.3f}',
        'Weighted_Avg_Precision': '{:.3f}',
        'Weighted_Avg_Recall': '{:.3f}',
        'Weighted_Avg_F1': '{:.3f}',
        'AUC': '{:.3f}'
    })

    print(df.to_string(index=False, float_format='%.3f'))

    return df

# Mostrar tabla
df_enhanced = display_enhanced_table(df_results_sorted)

# Crear tabla resumen de estadísticas
print("\n" + "=" * 100)
print("📈 Resumen de estadísticas de desempeño por modelo")
print("=" * 100)

summary_stats = pd.DataFrame({
    'Metric': ['Accuracy', 'AUC', 'Macro F1', 'Class 1 Recall', 'Class 1 F1'],
    'Best Model': [
        df_results.loc[df_results['Accuracy'].idxmax(), 'Model'],
        df_results.loc[df_results['AUC'].idxmax(), 'Model'],
        df_results.loc[df_results['Macro_Avg_F1'].idxmax(), 'Model'],
        df_results.loc[df_results['Recall_Class_1'].idxmax(), 'Model'],
        df_results.loc[df_results['F1_Score_Class_1'].idxmax(), 'Model']
    ],
    'Best Score': [
        f"{df_results['Accuracy'].max():.3f}",
        f"{df_results['AUC'].max():.3f}",
        f"{df_results['Macro_Avg_F1'].max():.3f}",
        f"{df_results['Recall_Class_1'].max():.3f}",
        f"{df_results['F1_Score_Class_1'].max():.3f}"
    ],
    'Worst Model': [
        df_results.loc[df_results['Accuracy'].idxmin(), 'Model'],
        df_results.loc[df_results['AUC'].idxmin(), 'Model'],
        df_results.loc[df_results['Macro_Avg_F1'].idxmin(), 'Model'],
        df_results.loc[df_results['Recall_Class_1'].idxmin(), 'Model'],
        df_results.loc[df_results['F1_Score_Class_1'].idxmin(), 'Model']
    ],
    'Worst Score': [
        f"{df_results['Accuracy'].min():.3f}",
        f"{df_results['AUC'].min():.3f}",
        f"{df_results['Macro_Avg_F1'].min():.3f}",
        f"{df_results['Recall_Class_1'].min():.3f}",
        f"{df_results['F1_Score_Class_1'].min():.3f}"
    ]
})

print(summary_stats.to_string(index=False))

# Create a compact comparison table for key metrics
print("\n" + "=" * 100)
print("🔍 Comparación de métricas claves (Ordenado por AUC)")
print("=" * 100)

key_metrics = df_results_sorted[['Rank', 'Model', 'Accuracy', 'AUC', 'Macro_Avg_F1', 'F1_Score_Class_1', 'Recall_Class_1']].copy()
key_metrics.columns = ['Rank', 'Model', 'Accuracy', 'AUC', 'Macro F1', 'Class 1 F1', 'Class 1 Recall']

print(key_metrics.to_string(index=False, float_format='%.3f'))

# Performance categorization
print("\n" + "=" * 100)
print("🏆 Categorización del desempeño")
print("=" * 100)

excellent = df_results_sorted[df_results_sorted['AUC'] >= 0.9]['Model'].tolist()
good = df_results_sorted[(df_results_sorted['AUC'] >= 0.8) & (df_results_sorted['AUC'] < 0.9)]['Model'].tolist()
moderate = df_results_sorted[(df_results_sorted['AUC'] >= 0.7) & (df_results_sorted['AUC'] < 0.8)]['Model'].tolist()
poor = df_results_sorted[df_results_sorted['AUC'] < 0.7]['Model'].tolist()

print(f"🥇 EXCELENTE (AUC ≥ 0.9): {', '.join(excellent) if excellent else 'None'}")
print(f"🥈 BUENO (0.8 ≤ AUC < 0.9): {', '.join(good) if good else 'None'}")
print(f"🥉 MODERADO (0.7 ≤ AUC < 0.8): {', '.join(moderate) if moderate else 'None'}")
print(f"❌ MALO (AUC < 0.7): {', '.join(poor) if poor else 'None'}")

🎯 Comparación del desempeño de los modelos de Machine Learning
====================================================================================================
📊 Dataset: Class 0 (3,850 samples) | Class 1 (85 samples) | Imbalance Ratio: 45.3:1
====================================================================================================
 Rank                   Model  Accuracy  Precision_Class_0  Recall_Class_0  F1_Score_Class_0  Precision_Class_1  Recall_Class_1  F1_Score_Class_1  Macro_Avg_Precision  Macro_Avg_Recall  Macro_Avg_F1  Weighted_Avg_Precision  Weighted_Avg_Recall  Weighted_Avg_F1   AUC
    1                 XGBoost     0.990              0.990           1.000             0.990              0.870           0.650             0.740                0.930             0.820         0.870                   0.990                0.990            0.990 0.962
    2           Random Forest     0.980              0.980           1.000             0.990              0.920           0.420             0.580                0.950             0.710         0.790                   0.980                0.980            0.980 0.928
    3     Logistic Regression     0.970              0.990           0.780             0.870              0.990           0.750             0.150                0.540             0.760         0.510                   0.970                0.970            0.850 0.851
    4   Multilayer Perceptron     0.970              0.980           0.990             0.990              0.510           0.450             0.480                0.750             0.720         0.730                   0.970                0.970            0.970 0.828
    5           Decision Tree     0.820              0.990           0.820             0.900              0.100           0.750             0.180                0.550             0.790         0.540                   0.970                0.820            0.880 0.825
    6                    K-NN     0.970              0.970           1.000             0.990              1.000           0.020             0.050                0.990             0.510         0.520                   0.970                0.970            0.950 0.820
    7 Bayesian Classification     0.220              1.000           0.200             0.330              0.050           0.960             0.060                0.510             0.580         0.200                   0.970                0.220            0.330 0.607

====================================================================================================
📈 Resumen de estadísticas de desempeño por modelo
====================================================================================================
        Metric              Best Model Best Score             Worst Model Worst Score
      Accuracy                 XGBoost      0.990 Bayesian Classification       0.220
           AUC                 XGBoost      0.962 Bayesian Classification       0.607
      Macro F1                 XGBoost      0.870 Bayesian Classification       0.200
Class 1 Recall Bayesian Classification      0.960                    K-NN       0.020
    Class 1 F1                 XGBoost      0.740                    K-NN       0.050

====================================================================================================
🔍 Comparación de métricas claves (Ordenado por AUC)
====================================================================================================
 Rank                   Model  Accuracy   AUC  Macro F1  Class 1 F1  Class 1 Recall
    1                 XGBoost     0.990 0.962     0.870       0.740           0.650
    2           Random Forest     0.980 0.928     0.790       0.580           0.420
    3     Logistic Regression     0.970 0.851     0.510       0.150           0.750
    4   Multilayer Perceptron     0.970 0.828     0.730       0.480           0.450
    5           Decision Tree     0.820 0.825     0.540       0.180           0.750
    6                    K-NN     0.970 0.820     0.520       0.050           0.020
    7 Bayesian Classification     0.220 0.607     0.200       0.060           0.960

====================================================================================================
🏆 Categorización del desempeño
====================================================================================================
🥇 EXCELENTE (AUC ≥ 0.9): XGBoost, Random Forest
🥈 BUENO (0.8 ≤ AUC < 0.9): Logistic Regression, Multilayer Perceptron, Decision Tree, K-NN
🥉 MODERADO (0.7 ≤ AUC < 0.8): None
❌ MALO (AUC < 0.7): Bayesian Classification

# Create visualizations
fig, axes = plt.subplots(2, 2, figsize=(15, 12))

# 1. Accuracy comparison
axes[0, 0].bar(df_results['Model'], df_results['Accuracy'], color='skyblue')
axes[0, 0].set_title('Model Accuracy Comparison')
axes[0, 0].set_ylabel('Accuracy')
axes[0, 0].tick_params(axis='x', rotation=45)
axes[0, 0].set_ylim(0, 1)

# 2. AUC comparison
axes[0, 1].bar(df_results['Model'], df_results['AUC'], color='lavender')
axes[0, 1].set_title('Model AUC Comparison')
axes[0, 1].set_ylabel('AUC')
axes[0, 1].tick_params(axis='x', rotation=45)
axes[0, 1].set_ylim(0, 1)

# 3. F1-Score comparison for both classes
x = range(len(df_results['Model']))
width = 0.35
axes[1, 0].bar([i - width/2 for i in x], df_results['F1_Score_Class_0'], width, label='Class 0', color='darkorange', alpha=0.7)
axes[1, 0].bar([i + width/2 for i in x], df_results['F1_Score_Class_1'], width, label='Class 1', color='lightcoral', alpha=0.7)
axes[1, 0].set_title('F1-Score Comparison by Class')
axes[1, 0].set_ylabel('F1-Score')
axes[1, 0].set_xticks(x)
axes[1, 0].set_xticklabels(df_results['Model'], rotation=45)
axes[1, 0].legend()
axes[1, 0].set_ylim(0, 1)

# 4. Macro Average F1-Score
axes[1, 1].bar(df_results['Model'], df_results['Macro_Avg_F1'], color='orchid', alpha=0.7)
axes[1, 1].set_title('Macro Average F1-Score Comparison')
axes[1, 1].set_ylabel('Macro Avg F1-Score')
axes[1, 1].tick_params(axis='x', rotation=45)
axes[1, 1].set_ylim(0, 1)

plt.tight_layout()
plt.show()

# Summary statistics
print("\n" + "=" * 80)
print("Mejores Resultados por métrica:")
print("=" * 80)
print(f"Accuracy más alto: {df_results.loc[df_results['Accuracy'].idxmax(), 'Model']} ({df_results['Accuracy'].max():.3f})")
print(f"AUC más alto: {df_results.loc[df_results['AUC'].idxmax(), 'Model']} ({df_results['AUC'].max():.3f})")
print(f"Macro F1 más alto: {df_results.loc[df_results['Macro_Avg_F1'].idxmax(), 'Model']} ({df_results['Macro_Avg_F1'].max():.3f})")
print(f"Mejor Clase 1 F1: {df_results.loc[df_results['F1_Score_Class_1'].idxmax(), 'Model']} ({df_results['F1_Score_Class_1'].max():.3f})")

================================================================================
Mejores Resultados por métrica:
================================================================================
Accuracy más alto: XGBoost (0.990)
AUC más alto: XGBoost (0.962)
Macro F1 más alto: XGBoost (0.870)
Mejor Clase 1 F1: XGBoost (0.740)

# Variables seleccionadas para el modelo reducido
selected_features = [
    'vento_rajada_max',
    'pressao_horaria',
    'temp_max_ant',
    'umid_horaria',
    'precipitacao'
]

def generar_splits_temporales(df, dias_entrenamiento, dias_validacion, selected_features=None, timesteps=0):
    horas_por_dia = 24
    ventanas = []
    total_dias = len(df) // horas_por_dia
    # Ensure validation window is large enough for timesteps
    min_val_days = (timesteps // horas_por_dia) + (1 if timesteps % horas_por_dia > 0 else 0)
    if dias_validacion < min_val_days:
        print(f"Warning: Increased validation window to at least {min_val_days} days to accommodate {timesteps} timesteps.")
        dias_validacion = min_val_days

    for i in range(total_dias - dias_entrenamiento - dias_validacion + 1):
        start_train = i * horas_por_dia
        end_train = (i + dias_entrenamiento) * horas_por_dia
        start_val = end_train
        end_val = start_val + dias_validacion * horas_por_dia

        train_df = df.iloc[start_train:end_train]
        val_df = df.iloc[start_val:end_val]

        if selected_features:
            X_train = train_df[selected_features]
            X_val = val_df[selected_features]
        else:
            X_train = train_df.drop(columns=['vento_velocidade', 'hora'], errors='ignore')
            X_val = val_df.drop(columns=['vento_velocidade', 'hora'], errors='ignore')

        y_train = train_df['vento_velocidade']
        y_val = val_df['vento_velocidade']

        ventanas.append((X_train, y_train, X_val, y_val))
    return ventanas

# Crear splits para T=7
splits_T7 = generar_splits_temporales(df, 7, 1, selected_features=selected_features)

# Get the first split to print shapes
X_train_wind, y_train_wind, X_val_wind, y_val_wind = splits_T7[0]

print("📊 Tamaños del primer split (T=7 días + 1 validación):")
print(f"X_train_wind: {X_train_wind.shape}, y_train_wind: {y_train_wind.shape}")
print(f"X_val_wind:   {X_val_wind.shape}, y_val_wind:   {y_val_wind.shape}")

📊 Tamaños del primer split (T=7 días + 1 validación):
X_train_wind: (168, 5), y_train_wind: (168,)
X_val_wind:   (24, 5), y_val_wind:   (24,)

splits_T14 = generar_splits_temporales(df, 14, 1, selected_features=selected_features)

print("📊 Tamaños del primer split (T=14 días + 1 validación):")
print(f"X_train_wind: {X_train_wind.shape}, y_train_wind: {y_train_wind.shape}")
print(f"X_val_wind:   {X_val_wind.shape}, y_val_wind:   {y_val_wind.shape}")

📊 Tamaños del primer split (T=14 días + 1 validación):
X_train_wind: (168, 5), y_train_wind: (168,)
X_val_wind:   (24, 5), y_val_wind:   (24,)

splits_T21 = generar_splits_temporales(df, 21, 1, selected_features=selected_features)

print("📊 Tamaños del primer split (T=21 días + 1 validación):")
print(f"X_train_wind: {X_train_wind.shape}, y_train_wind: {y_train_wind.shape}")
print(f"X_val_wind:   {X_val_wind.shape}, y_val_wind:   {y_val_wind.shape}")

📊 Tamaños del primer split (T=21 días + 1 validación):
X_train_wind: (168, 5), y_train_wind: (168,)
X_val_wind:   (24, 5), y_val_wind:   (24,)

def calcular_mape_seguro(y_true, y_pred):
    y_true_safe = np.where(y_true == 0, 0.01, y_true)
    return np.mean(np.abs((y_true - y_pred) / y_true_safe)) * 100

def entrenar_knn_splits(splits, nombre_ventana):
    metricas_knn = []

    for X_train_wind, y_train_wind, X_val_wind, y_val_wind in splits:
        scaler = StandardScaler()
        X_train_scaled = scaler.fit_transform(X_train_wind)
        X_val_scaled = scaler.transform(X_val_wind)

        modelo_knn = KNeighborsRegressor(n_neighbors=5)
        modelo_knn.fit(X_train_scaled, y_train_wind)
        y_pred = modelo_knn.predict(X_val_scaled)

        mae = mean_absolute_error(y_val_wind, y_pred)
        mape = calcular_mape_seguro(y_val_wind, y_pred)
        mse = mean_squared_error(y_val_wind, y_pred)
        rmse = np.sqrt(mse)

        # Test de autocorrelación de residuos
        residuos = y_val_wind - y_pred
        lb_test = acorr_ljungbox(residuos, lags=[1], return_df=True)
        p_valor = lb_test['lb_pvalue'].values[0]

        metricas_knn.append({
            "Ventana": nombre_ventana,
            "MAE": mae,
            "MAPE": mape,
            "MSE": mse,
            "RMSE": rmse,
            "p_valor_LjungBox": p_valor
        })

    return pd.DataFrame(metricas_knn)

# Ejecutar para T=7, T=14, T=21
df_knn_T7 = entrenar_knn_splits(splits_T7, "T=7")
df_knn_T14 = entrenar_knn_splits(splits_T14, "T=14")
df_knn_T21 = entrenar_knn_splits(splits_T21, "T=21")

# Combinar y calcular promedios
resultados_knn = pd.concat([df_knn_T7, df_knn_T14, df_knn_T21])
promedios_knn = resultados_knn.groupby("Ventana").mean().reset_index()

print("\n Promedios del modelo K-NN Regressor por ventana:")
print(promedios_knn.round(4))

 Promedios del modelo K-NN Regressor por ventana:
  Ventana     MAE      MAPE     MSE    RMSE  p_valor_LjungBox
0    T=14  0.5459  246.2973  0.5067  0.6907            0.3757
1    T=21  0.5312  238.0413  0.4815  0.6739            0.3948
2     T=7  0.5807  267.8269  0.5705  0.7308            0.3338

def entrenar_lr_splits(splits, nombre_ventana):
    metricas_lr = []

    for X_train_wind, y_train_wind, X_val_wind, y_val_wind in splits:
        # Escalar datos
        scaler = StandardScaler()
        X_train_scaled = scaler.fit_transform(X_train_wind)
        X_val_scaled = scaler.transform(X_val_wind)

        # Modelo de Regresión Lineal
        modelo_lr = LinearRegression()
        modelo_lr.fit(X_train_scaled, y_train_wind)
        y_pred = modelo_lr.predict(X_val_scaled)

        # Métricas
        mae = mean_absolute_error(y_val_wind, y_pred)
        mape = calcular_mape_seguro(y_val_wind, y_pred)
        mse = mean_squared_error(y_val_wind, y_pred)
        rmse = np.sqrt(mse)

        # Test de Ljung-Box
        residuos = y_val_wind - y_pred
        lb_test = acorr_ljungbox(residuos, lags=[1], return_df=True)
        p_valor = lb_test['lb_pvalue'].values[0]

        metricas_lr.append({
            "Ventana": nombre_ventana,
            "MAE": mae,
            "MAPE": mape,
            "MSE": mse,
            "RMSE": rmse,
            "p_valor_LjungBox": p_valor
        })

    return pd.DataFrame(metricas_lr)

# Entrenar modelo para cada ventana
df_lr_T7 = entrenar_lr_splits(splits_T7, "T=7")
df_lr_T14 = entrenar_lr_splits(splits_T14, "T=14")
df_lr_T21 = entrenar_lr_splits(splits_T21, "T=21")

# Combinar y calcular promedios
resultados_lr = pd.concat([df_lr_T7, df_lr_T14, df_lr_T21])
promedios_lr = resultados_lr.groupby("Ventana").mean().reset_index()

print("\n Promedios del modelo de Regresión Lineal por ventana:")
print(promedios_lr.round(4))

 Promedios del modelo de Regresión Lineal por ventana:
  Ventana     MAE      MAPE     MSE    RMSE  p_valor_LjungBox
0    T=14  0.4749  197.6838  0.5559  0.6203            0.4468
1    T=21  0.4671  196.8841  0.3985  0.6028            0.4485
2     T=7  0.4887  198.7880  0.6773  0.6458            0.4387

def entrenar_ridge_splits(splits, nombre_ventana, alpha=1.0):
    metricas_ridge = []

    for X_train, y_train, X_val, y_val in splits:
        scaler = StandardScaler()
        X_train_scaled = scaler.fit_transform(X_train)
        X_val_scaled = scaler.transform(X_val)

        modelo_ridge = Ridge(alpha=alpha)
        modelo_ridge.fit(X_train_scaled, y_train)
        y_pred = modelo_ridge.predict(X_val_scaled)

        mae = mean_absolute_error(y_val, y_pred)
        mape = calcular_mape_seguro(y_val, y_pred)
        mse = mean_squared_error(y_val, y_pred)
        rmse = np.sqrt(mse)

        residuos = y_val - y_pred
        lb_test = acorr_ljungbox(residuos, lags=[1], return_df=True)
        p_valor = lb_test['lb_pvalue'].values[0]

        metricas_ridge.append({
            "Ventana": nombre_ventana,
            "MAE": mae,
            "MAPE": mape,
            "MSE": mse,
            "RMSE": rmse,
            "p_valor_LjungBox": p_valor
        })

    return pd.DataFrame(metricas_ridge)


# Ejemplo de ejecución para las mismas ventanas T=7, T=14, T=21
df_ridge_T7 = entrenar_ridge_splits(splits_T7, "T=7", alpha=1.0)
df_ridge_T14 = entrenar_ridge_splits(splits_T14, "T=14", alpha=1.0)
df_ridge_T21 = entrenar_ridge_splits(splits_T21, "T=21", alpha=1.0)

resultados_ridge = pd.concat([df_ridge_T7, df_ridge_T14, df_ridge_T21])
promedios_ridge = resultados_ridge.groupby("Ventana").mean().reset_index()

print("\n Promedios del modelo Ridge Regressor por ventana:")
print(promedios_ridge.round(4))

 Promedios del modelo Ridge Regressor por ventana:
  Ventana     MAE      MAPE     MSE    RMSE  p_valor_LjungBox
0    T=14  0.4749  198.7291  0.5539  0.6201            0.4463
1    T=21  0.4672  197.5445  0.3985  0.6027            0.4481
2     T=7  0.4881  200.8995  0.6643  0.6443            0.4382

def entrenar_lasso_splits(splits, nombre_ventana, alpha=1.0):
    metricas_lasso = []

    for X_train, y_train, X_val, y_val in splits:
        scaler = StandardScaler()
        X_train_scaled = scaler.fit_transform(X_train)
        X_val_scaled = scaler.transform(X_val)

        modelo_lasso = Lasso(alpha=alpha, max_iter=10000)
        modelo_lasso.fit(X_train_scaled, y_train)
        y_pred = modelo_lasso.predict(X_val_scaled)

        mae = mean_absolute_error(y_val, y_pred)
        mape = calcular_mape_seguro(y_val, y_pred)
        mse = mean_squared_error(y_val, y_pred)
        rmse = np.sqrt(mse)

        residuos = y_val - y_pred
        lb_test = acorr_ljungbox(residuos, lags=[1], return_df=True)
        p_valor = lb_test['lb_pvalue'].values[0]

        metricas_lasso.append({
            "Ventana": nombre_ventana,
            "MAE": mae,
            "MAPE": mape,
            "MSE": mse,
            "RMSE": rmse,
            "p_valor_LjungBox": p_valor
        })

    return pd.DataFrame(metricas_lasso)


# Ejemplo de ejecución para las ventanas T=7, T=14, T=21
df_lasso_T7 = entrenar_lasso_splits(splits_T7, "T=7", alpha=1.0)
df_lasso_T14 = entrenar_lasso_splits(splits_T14, "T=14", alpha=1.0)
df_lasso_T21 = entrenar_lasso_splits(splits_T21, "T=21", alpha=1.0)

resultados_lasso = pd.concat([df_lasso_T7, df_lasso_T14, df_lasso_T21])
promedios_lasso = resultados_lasso.groupby("Ventana").mean().reset_index()

print("\n Promedios del modelo Lasso Regressor por ventana:")
print(promedios_lasso.round(4))

 Promedios del modelo Lasso Regressor por ventana:
  Ventana     MAE      MAPE     MSE    RMSE  p_valor_LjungBox
0    T=14  0.9853  630.2549  1.4965  1.1843            0.0597
1    T=21  0.9772  627.0319  1.4694  1.1741            0.0612
2     T=7  0.9915  622.4506  1.5252  1.1928            0.0574

def entrenar_decision_tree_splits(splits, nombre_ventana, max_depth=None, random_state=42):
    metricas_dt = []

    for X_train, y_train, X_val, y_val in splits:
        # Para árboles no es obligatorio escalar, pero puedes hacerlo si quieres
        modelo_dt = DecisionTreeRegressor(max_depth=max_depth, random_state=random_state)
        modelo_dt.fit(X_train, y_train)
        y_pred = modelo_dt.predict(X_val)

        mae = mean_absolute_error(y_val, y_pred)
        mape = calcular_mape_seguro(y_val, y_pred)
        mse = mean_squared_error(y_val, y_pred)
        rmse = np.sqrt(mse)

        residuos = y_val - y_pred
        lb_test = acorr_ljungbox(residuos, lags=[1], return_df=True)
        p_valor = lb_test['lb_pvalue'].values[0]

        metricas_dt.append({
            "Ventana": nombre_ventana,
            "MAE": mae,
            "MAPE": mape,
            "MSE": mse,
            "RMSE": rmse,
            "p_valor_LjungBox": p_valor
        })

    return pd.DataFrame(metricas_dt)


# Ejemplo de ejecución para ventanas T=7, T=14, T=21
df_dt_T7 = entrenar_decision_tree_splits(splits_T7, "T=7", max_depth=5)
df_dt_T14 = entrenar_decision_tree_splits(splits_T14, "T=14", max_depth=5)
df_dt_T21 = entrenar_decision_tree_splits(splits_T21, "T=21", max_depth=5)

resultados_dt = pd.concat([df_dt_T7, df_dt_T14, df_dt_T21])
promedios_dt = resultados_dt.groupby("Ventana").mean().reset_index()

print("\n Promedios del modelo Decision Tree Regressor por ventana:")
print(promedios_dt.round(4))

 Promedios del modelo Decision Tree Regressor por ventana:
  Ventana     MAE      MAPE     MSE    RMSE  p_valor_LjungBox
0    T=14  0.5423  187.8660  0.5308  0.7040            0.4322
1    T=21  0.5231  185.4895  0.4944  0.6787            0.4485
2     T=7  0.5893  201.5786  0.6258  0.7624            0.4166

# def entrenar_random_forest_splits(splits, nombre_ventana, n_estimators=50, max_depth=5, random_state=42, n_jobs=-1):
#     metricas_rf = []

#     for X_train, y_train, X_val, y_val in splits:
#         # Escalar no es estrictamente necesario para Random Forest
#         modelo_rf = RandomForestRegressor(n_estimators=n_estimators, max_depth=max_depth, random_state=random_state)
#         modelo_rf.fit(X_train, y_train)
#         y_pred = modelo_rf.predict(X_val)

#         mae = mean_absolute_error(y_val, y_pred)
#         mape = calcular_mape_seguro(y_val, y_pred)
#         mse = mean_squared_error(y_val, y_pred)
#         rmse = np.sqrt(mse)

#         residuos = y_val - y_pred
#         lb_test = acorr_ljungbox(residuos, lags=[1], return_df=True)
#         p_valor = lb_test['lb_pvalue'].values[0]

#         metricas_rf.append({
#             "Ventana": nombre_ventana,
#             "MAE": mae,
#             "MAPE": mape,
#             "MSE": mse,
#             "RMSE": rmse,
#             "p_valor_LjungBox": p_valor
#         })

#     return pd.DataFrame(metricas_rf)


# # Ejemplo de ejecución para ventanas T=7, T=14, T=21
# df_rf_T7 = entrenar_random_forest_splits(splits_T7, "T=7", n_estimators=50, max_depth=5)
# df_rf_T14 = entrenar_random_forest_splits(splits_T14, "T=14", n_estimators=50, max_depth=5)
# df_rf_T21 = entrenar_random_forest_splits(splits_T21, "T=21", n_estimators=50, max_depth=5)

# resultados_rf = pd.concat([df_rf_T7, df_rf_T14, df_rf_T21])
# promedios_rf = resultados_rf.groupby("Ventana").mean().reset_index()

# print("\n Promedios del modelo Random Forest Regressor por ventana:")
# print(promedios_rf.round(4))

def entrenar_xgboost_splits(splits, nombre_ventana, n_estimators=100, max_depth=6, learning_rate=0.1, random_state=42):
    metricas_xgb = []

    for X_train, y_train, X_val, y_val in splits:
        # Escalar no es obligatorio para XGBoost
        modelo_xgb = xgb.XGBRegressor(
            n_estimators=n_estimators,
            max_depth=max_depth,
            learning_rate=learning_rate,
            random_state=random_state,
            verbosity=0
        )
        modelo_xgb.fit(X_train, y_train)
        y_pred = modelo_xgb.predict(X_val)

        mae = mean_absolute_error(y_val, y_pred)
        mape = calcular_mape_seguro(y_val, y_pred)
        mse = mean_squared_error(y_val, y_pred)
        rmse = np.sqrt(mse)

        residuos = y_val - y_pred
        lb_test = acorr_ljungbox(residuos, lags=[1], return_df=True)
        p_valor = lb_test['lb_pvalue'].values[0]

        metricas_xgb.append({
            "Ventana": nombre_ventana,
            "MAE": mae,
            "MAPE": mape,
            "MSE": mse,
            "RMSE": rmse,
            "p_valor_LjungBox": p_valor
        })

    return pd.DataFrame(metricas_xgb)


# Ejemplo de ejecución para ventanas T=7, T=14, T=21
df_xgb_T7 = entrenar_xgboost_splits(splits_T7, "T=7", n_estimators=100, max_depth=6, learning_rate=0.1)
df_xgb_T14 = entrenar_xgboost_splits(splits_T14, "T=14", n_estimators=100, max_depth=6, learning_rate=0.1)
df_xgb_T21 = entrenar_xgboost_splits(splits_T21, "T=21", n_estimators=100, max_depth=6, learning_rate=0.1)

resultados_xgb = pd.concat([df_xgb_T7, df_xgb_T14, df_xgb_T21])
promedios_xgb = resultados_xgb.groupby("Ventana").mean().reset_index()

print("\n Promedios del modelo XGBoost Regressor por ventana:")
print(promedios_xgb.round(4))

 Promedios del modelo XGBoost Regressor por ventana:
  Ventana     MAE      MAPE     MSE    RMSE  p_valor_LjungBox
0    T=14  0.5282  201.3237  0.4858  0.6766            0.4332
1    T=21  0.5133  197.8739  0.4621  0.6595            0.4418
2     T=7  0.5587  220.4712  0.5427  0.7138            0.4092

# def entrenar_svr_splits(splits, nombre_ventana, kernel='rbf', C=1.0, epsilon=0.1):
#     metricas_svr = []

#     for X_train, y_train, X_val, y_val in splits:
#         scaler = StandardScaler()
#         X_train_scaled = scaler.fit_transform(X_train)
#         X_val_scaled = scaler.transform(X_val)

#         modelo_svr = SVR(kernel=kernel, C=C, epsilon=epsilon)
#         modelo_svr.fit(X_train_scaled, y_train)
#         y_pred = modelo_svr.predict(X_val_scaled)

#         mae = mean_absolute_error(y_val, y_pred)
#         mape = calcular_mape_seguro(y_val, y_pred)
#         mse = mean_squared_error(y_val, y_pred)
#         rmse = np.sqrt(mse)

#         residuos = y_val - y_pred
#         lb_test = acorr_ljungbox(residuos, lags=[1], return_df=True)
#         p_valor = lb_test['lb_pvalue'].values[0]

#         metricas_svr.append({
#             "Ventana": nombre_ventana,
#             "MAE": mae,
#             "MAPE": mape,
#             "MSE": mse,
#             "RMSE": rmse,
#             "p_valor_LjungBox": p_valor
#         })

#     return pd.DataFrame(metricas_svr)


# # Ejemplo de ejecución para ventanas T=7, T=14, T=21
# df_svr_T7 = entrenar_svr_splits(splits_T7, "T=7", kernel='rbf', C=1.0, epsilon=0.1)
# df_svr_T14 = entrenar_svr_splits(splits_T14, "T=14", kernel='rbf', C=1.0, epsilon=0.1)
# df_svr_T21 = entrenar_svr_splits(splits_T21, "T=21", kernel='rbf', C=1.0, epsilon=0.1)

# resultados_svr = pd.concat([df_svr_T7, df_svr_T14, df_svr_T21])
# promedios_svr = resultados_svr.groupby("Ventana").mean().reset_index()

# print("\nPromedios del modelo SVR Regressor por ventana:")
# print(promedios_svr.round(4))

# def entrenar_mlp_splits(splits, nombre_ventana, hidden_layer_sizes=(100,), activation='relu', solver='adam', max_iter=500, random_state=42):
#     metricas_mlp = []

#     for X_train, y_train, X_val, y_val in splits:
#         scaler = StandardScaler()
#         X_train_scaled = scaler.fit_transform(X_train)
#         X_val_scaled = scaler.transform(X_val)

#         modelo_mlp = MLPRegressor(
#             hidden_layer_sizes=(100,),
#             activation='relu',
#             solver='adam',
#             max_iter=1000,
#             random_state=42,
#             early_stopping=True,
#             n_iter_no_change=10,
#             learning_rate_init=0.0005,
#             verbose=True
#         )

#         modelo_mlp.fit(X_train_scaled, y_train)
#         y_pred = modelo_mlp.predict(X_val_scaled)

#         mae = mean_absolute_error(y_val, y_pred)
#         mape = calcular_mape_seguro(y_val, y_pred)
#         mse = mean_squared_error(y_val, y_pred)
#         rmse = np.sqrt(mse)

#         residuos = y_val - y_pred
#         lb_test = acorr_ljungbox(residuos, lags=[1], return_df=True)
#         p_valor = lb_test['lb_pvalue'].values[0]

#         metricas_mlp.append({
#             "Ventana": nombre_ventana,
#             "MAE": mae,
#             "MAPE": mape,
#             "MSE": mse,
#             "RMSE": rmse,
#             "p_valor_LjungBox": p_valor
#         })

#     return pd.DataFrame(metricas_mlp)


# # Ejecución para las tres ventanas
# df_mlp_T7 = entrenar_mlp_splits(splits_T7, "T=7", hidden_layer_sizes=(100,), max_iter=500)
# df_mlp_T14 = entrenar_mlp_splits(splits_T14, "T=14", hidden_layer_sizes=(100,), max_iter=500)
# df_mlp_T21 = entrenar_mlp_splits(splits_T21, "T=21", hidden_layer_sizes=(100,), max_iter=500)

# resultados_mlp = pd.concat([df_mlp_T7, df_mlp_T14, df_mlp_T21])
# promedios_mlp = resultados_mlp.groupby("Ventana").mean().reset_index()

# print("\nPromedios del modelo MLP Regressor por ventana:")
# print(promedios_mlp.round(4))

# def preparar_datos_rnn(X, y, timesteps=24):
#     X = X.copy()
#     y = y.reset_index(drop=True)

#     num_samples = len(X) - timesteps
#     if num_samples <= 0:
#         raise ValueError(f"Not enough samples: got {len(X)}, need at least {timesteps + 1}")

#     X_seq = np.zeros((num_samples, timesteps, X.shape[1]))
#     y_seq = np.zeros((num_samples,))

#     X_values = X.values

#     for i in range(num_samples):
#         X_seq[i] = X_values[i:i + timesteps]
#         y_seq[i] = y.iloc[i + timesteps]

#     return X_seq, y_seq

# def entrenar_rnn_splits(splits, nombre_ventana, timesteps=24, units=50, epochs=20, batch_size=32, verbose=0):
#     metricas_rnn = []

#     for X_train, y_train, X_val, y_val in splits:
#         # Ensure column consistency
#         X_val = X_val[X_train.columns]

#         # Normalizar
#         scaler = StandardScaler()
#         X_train_scaled = scaler.fit_transform(X_train)
#         X_val_scaled = scaler.transform(X_val)

#         # Reconstruir DataFrames para mantener columnas
#         X_train_df = pd.DataFrame(X_train_scaled, columns=X_train.columns)
#         X_val_df = pd.DataFrame(X_val_scaled, columns=X_val.columns)

#         # Convertir a secuencias
#         X_train_seq, y_train_seq = preparar_datos_rnn(X_train_df, y_train.reset_index(drop=True), timesteps)
#         X_val_seq, y_val_seq = preparar_datos_rnn(X_val_df, y_val.reset_index(drop=True), timesteps)

#         # Construir modelo RNN
#         model = Sequential()
#         model.add(Input(shape=(timesteps, X_train_seq.shape[2])))
#         model.add(SimpleRNN(units, activation='tanh'))
#         model.add(Dense(1))
#         model.compile(optimizer=Adam(), loss='mse')

#         model.fit(X_train_seq, y_train_seq, epochs=epochs, batch_size=batch_size, verbose=verbose)

#         y_pred = model.predict(X_val_seq).flatten()

#         # Métricas
#         mae = mean_absolute_error(y_val_seq, y_pred)
#         mape = calcular_mape_seguro(y_val_seq, y_pred)
#         mse = mean_squared_error(y_val_seq, y_pred)
#         rmse = np.sqrt(mse)

#         residuos = y_val_seq - y_pred
#         epsilon = 1e-10
#         residuos_safe = residuos + epsilon if np.any(residuos <= 0) else residuos

#         lb_test = acorr_ljungbox(residuos_safe, lags=[1], return_df=True)
#         p_valor = lb_test['lb_pvalue'].values[0]

#         metricas_rnn.append({
#             "Ventana": nombre_ventana,
#             "MAE": mae,
#             "MAPE": mape,
#             "MSE": mse,
#             "RMSE": rmse,
#             "p_valor_LjungBox": p_valor
#         })

#     return pd.DataFrame(metricas_rnn)

# df_rnn_T7 = entrenar_rnn_splits(generar_splits_temporales(df, 7, 2, selected_features=selected_features, timesteps=24), "T=7", timesteps=24)
# df_rnn_T14 = entrenar_rnn_splits(generar_splits_temporales(df, 14, 2, selected_features=selected_features, timesteps=24), "T=14", timesteps=24)
# df_rnn_T21 = entrenar_rnn_splits(generar_splits_temporales(df, 21, 2, selected_features=selected_features, timesteps=24), "T=21", timesteps=24)

# resultados_rnn = pd.concat([df_rnn_T7, df_rnn_T14, df_rnn_T21])
# promedios_rnn = resultados_rnn.groupby("Ventana").mean().reset_index()

# print("\nPromedios del modelo RNN por ventana:")
# print(promedios_rnn.round(4))

def preparar_datos_lstm(X, y, timesteps=24):
    X_seq, y_seq = [], []
    for i in range(len(X) - timesteps):
        X_seq.append(X.iloc[i:i+timesteps].values)
        y_seq.append(y.iloc[i+timesteps])
    return np.array(X_seq), np.array(y_seq)

def entrenar_lstm_splits(splits, nombre_ventana, timesteps=24, units=50, epochs=20, batch_size=32, verbose=0):
    metricas_lstm = []

    for X_train, y_train, X_val, y_val in splits:
        # Escalar
        scaler = StandardScaler()
        X_train_scaled = scaler.fit_transform(X_train)
        X_val_scaled = scaler.transform(X_val)

        # Reconstruir DataFrames
        X_train_df = pd.DataFrame(X_train_scaled, columns=X_train.columns)
        X_val_df = pd.DataFrame(X_val_scaled, columns=X_val.columns)

        # Convertir a secuencias
        X_train_seq, y_train_seq = preparar_datos_lstm(X_train_df, y_train.reset_index(drop=True), timesteps)
        X_val_seq, y_val_seq = preparar_datos_lstm(X_val_df, y_val.reset_index(drop=True), timesteps)

        # Modelo LSTM
        model = Sequential()
        model.add(LSTM(units, activation='tanh', input_shape=(timesteps, X_train_seq.shape[2])))
        model.add(Dense(1))
        model.compile(optimizer=Adam(), loss='mse')

        model.fit(X_train_seq, y_train_seq, epochs=epochs, batch_size=batch_size, verbose=verbose)

        y_pred = model.predict(X_val_seq).flatten()

        # Métricas
        mae = mean_absolute_error(y_val_seq, y_pred)
        mape = calcular_mape_seguro(y_val_seq, y_pred)
        mse = mean_squared_error(y_val_seq, y_pred)
        rmse = np.sqrt(mse)

        residuos = y_val_seq - y_pred
        lb_test = acorr_ljungbox(residuos, lags=[1], return_df=True)
        p_valor = lb_test['lb_pvalue'].values[0]

        metricas_lstm.append({
            "Ventana": nombre_ventana,
            "MAE": mae,
            "MAPE": mape,
            "MSE": mse,
            "RMSE": rmse,
            "p_valor_LjungBox": p_valor
        })

    return pd.DataFrame(metricas_lstm)

df_lstm_T7 = entrenar_lstm_splits(generar_splits_temporales(df, 7, 2, selected_features=selected_features, timesteps=24), "T=7", timesteps=24, epochs=20)
df_lstm_T14 = entrenar_lstm_splits(generar_splits_temporales(df, 14, 2, selected_features=selected_features, timesteps=24), "T=14", timesteps=24, epochs=20)
df_lstm_T21 = entrenar_lstm_splits(generar_splits_temporales(df, 21, 2, selected_features=selected_features, timesteps=24), "T=21", timesteps=24, epochs=20)

resultados_lstm = pd.concat([df_lstm_T7, df_lstm_T14, df_lstm_T21])
promedios_lstm = resultados_lstm.groupby("Ventana").mean().reset_index()

print("\nPromedios del modelo LSTM por ventana:")
print(promedios_lstm.round(4))

# Datos por modelo y ventana
data = {
    'Modelo': ['K-NN', 'K-NN', 'K-NN',
               'Regresión Lineal', 'Regresión Lineal', 'Regresión Lineal',
               'Ridge', 'Ridge', 'Ridge',
               'Lasso', 'Lasso', 'Lasso',
               'Decision Tree', 'Decision Tree', 'Decision Tree',
               'XGBoost', 'XGBoost', 'XGBoost'],
    'Ventana': ['T=7', 'T=14', 'T=21'] * 6,
    'MAE': [0.5807, 0.5459, 0.5312,
            0.4887, 0.4749, 0.4671,
            0.4881, 0.4749, 0.4672,
            0.9915, 0.9853, 0.9772,
            0.5893, 0.5423, 0.5231,
            0.5587, 0.5282, 0.5133],
    'MAPE': [267.83, 246.30, 238.04,
             198.79, 197.68, 196.88,
             200.90, 198.73, 197.54,
             622.45, 630.25, 627.03,
             201.58, 187.87, 185.49,
             220.47, 201.32, 197.87],
    'MSE': [0.5705, 0.5067, 0.4815,
            0.6773, 0.5559, 0.3985,
            0.6643, 0.5539, 0.3985,
            1.5252, 1.4965, 1.4694,
            0.6258, 0.5308, 0.4944,
            0.5427, 0.4858, 0.4621],
    'RMSE': [0.7308, 0.6907, 0.6739,
             0.6458, 0.6203, 0.6028,
             0.6443, 0.6201, 0.6027,
             1.1928, 1.1843, 1.1741,
             1.5252, 1.4965, 1.4694,
             0.7138, 0.6766, 0.6595],
    'p_valor_LjungBox': [0.3338, 0.3757, 0.3948,
                         0.4387, 0.4468, 0.4485,
                         0.4382, 0.4463, 0.4481,
                         0.0574, 0.0597, 0.0612,
                         0.4166, 0.4322, 0.4485,
                         0.4092, 0.4332, 0.4418]
}

# Crear DataFrame
df_summary = pd.DataFrame(data)

# Mostrar tabla
display(df_summary)

	HORA (UTC)	VENTO, DIREï¿½ï¿½O HORARIA (gr) (ï¿½ (gr))	VENTO, VELOCIDADE HORARIA (m/s)	UMIDADE REL. MAX. NA HORA ANT. (AUT) (%)	UMIDADE REL. MIN. NA HORA ANT. (AUT) (%)	TEMPERATURA Mï¿½XIMA NA HORA ANT. (AUT) (ï¿½C)	TEMPERATURA Mï¿½NIMA NA HORA ANT. (AUT) (ï¿½C)	UMIDADE RELATIVA DO AR, HORARIA (%)	PRESSAO ATMOSFERICA AO NIVEL DA ESTACAO, HORARIA (mB)	VENTO, RAJADA MAXIMA (m/s)	PRESSï¿½O ATMOSFERICA MAX.NA HORA ANT. (AUT) (mB)	PRESSï¿½O ATMOSFERICA MIN. NA HORA ANT. (AUT) (mB)
0	12:00	0.809017	1.8	69.0	60.0	22.6	20.7	61.0	888.2	3.8	888.2	887.7
1	13:00	0.965926	2.7	62.0	55.0	24.2	22.5	55.0	888.4	4.7	888.4	888.2
2	14:00	0.891007	2.0	56.0	50.0	25.5	24.3	51.0	888.1	4.9	888.4	888.1
3	15:00	0.848048	2.5	52.0	44.0	27.4	25.0	44.0	887.4	5.8	888.1	887.4
4	16:00	0.224951	2.4	50.0	43.0	27.1	25.5	46.0	886.5	5.8	887.4	886.5

	vento_direcao	vento_velocidade	umid_max_ant	umid_min_ant	temp_max_ant	temp_min_ant	umid_horaria	pressao_horaria	precipitacao	vento_rajada_max	pressao_max_ant	pressao_min_ant
count	87693.000000	87693.000000	87693.000000	87693.000000	87693.000000	87693.000000	87693.000000	87693.000000	87693.000000	87693.000000	87693.000000	87693.000000
mean	0.405810	2.466192	69.058465	63.176194	21.921264	20.684570	66.146682	887.251925	0.160907	5.161076	887.580724	886.891093
std	0.686247	1.313968	19.640222	20.166336	3.721386	3.513744	19.992327	4.012404	1.307515	2.311157	3.646750	3.564539
min	-1.000000	0.000000	12.000000	10.000000	9.200000	8.400000	10.000000	863.400000	0.000000	0.000000	865.300000	862.800000
25%	-0.156434	1.500000	54.000000	48.000000	19.200000	18.400000	51.000000	885.300000	0.000000	3.400000	885.600000	885.000000
50%	0.788011	2.400000	72.000000	64.000000	21.400000	20.200000	68.000000	887.200000	0.000000	5.000000	887.500000	886.900000
75%	0.970296	3.400000	87.000000	80.000000	24.700000	23.100000	84.000000	889.100000	0.000000	6.800000	889.300000	888.800000
max	1.000000	10.000000	100.000000	98.000000	35.300000	34.400000	99.000000	1023.500000	70.800000	24.300000	913.100000	910.900000

	TransactionID	TransactionDT	TransactionAmt	ProductCD	card1	card2	card3	card4	card5	...	id_31	id_32	id_33	id_34	id_35	id_36	id_37	id_38	DeviceType	DeviceInfo
0	2987000	86400	68.5	W	13926	NaN	150.0	discover	142.0	...	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
1	2987001	86401	29.0	W	2755	404.0	150.0	mastercard	102.0	...	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
2	2987002	86469	59.0	W	4663	490.0	150.0	visa	166.0	...	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
3	2987003	86499	50.0	W	18132	567.0	150.0	mastercard	117.0	...	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
4	2987004	86506	50.0	H	4497	514.0	150.0	mastercard	102.0	...	samsung browser 6.2	32.0	2220x1080	match_status:2	T	F	T	T	mobile	SAMSUNG SM-G892A Build/NRD90M

	Missing Count	Missing %
id_24	51552	98.866578
id_25	51513	98.791784
id_21	51507	98.780277
id_08	51504	98.774524
id_07	51504	98.774524
id_23	51503	98.772606
id_26	51503	98.772606
id_27	51503	98.772606
id_22	51503	98.772606
D7	49659	95.236177

	TransactionID	TransactionDT	TransactionAmt	ProductCD	card1	card2	card3	card4	card5	card6	...	id_31	id_32	id_33	id_34	id_35	id_36	id_37	id_38	DeviceType	DeviceInfo
0	2987000.0	86400.0	68.5	4.0	13926.0	370.0	150.0	1.0	142.0	1.0	...	57.0	24.0	89.0	3.0	2.0	2.0	2.0	2.0	1.0	572.0
1	2987001.0	86401.0	29.0	4.0	2755.0	404.0	150.0	2.0	102.0	1.0	...	57.0	24.0	89.0	3.0	2.0	2.0	2.0	2.0	1.0	572.0
2	2987002.0	86469.0	59.0	4.0	4663.0	490.0	150.0	4.0	166.0	2.0	...	57.0	24.0	89.0	3.0	2.0	2.0	2.0	2.0	1.0	572.0
3	2987003.0	86499.0	50.0	4.0	18132.0	567.0	150.0	2.0	117.0	2.0	...	57.0	24.0	89.0	3.0	2.0	2.0	2.0	2.0	1.0	572.0
4	2987004.0	86506.0	50.0	1.0	4497.0	514.0	150.0	2.0	102.0	1.0	...	72.0	32.0	51.0	2.0	1.0	0.0	1.0	1.0	2.0	285.0

	Modelo	Ventana	MAE	MAPE	MSE	RMSE	p_valor_LjungBox
0	K-NN	T=7	0.5807	267.83	0.5705	0.7308	0.3338
1	K-NN	T=14	0.5459	246.30	0.5067	0.6907	0.3757
2	K-NN	T=21	0.5312	238.04	0.4815	0.6739	0.3948
3	Regresión Lineal	T=7	0.4887	198.79	0.6773	0.6458	0.4387
4	Regresión Lineal	T=14	0.4749	197.68	0.5559	0.6203	0.4468
5	Regresión Lineal	T=21	0.4671	196.88	0.3985	0.6028	0.4485
6	Ridge	T=7	0.4881	200.90	0.6643	0.6443	0.4382
7	Ridge	T=14	0.4749	198.73	0.5539	0.6201	0.4463
8	Ridge	T=21	0.4672	197.54	0.3985	0.6027	0.4481
9	Lasso	T=7	0.9915	622.45	1.5252	1.1928	0.0574
10	Lasso	T=14	0.9853	630.25	1.4965	1.1843	0.0597
11	Lasso	T=21	0.9772	627.03	1.4694	1.1741	0.0612
12	Decision Tree	T=7	0.5893	201.58	0.6258	1.5252	0.4166
13	Decision Tree	T=14	0.5423	187.87	0.5308	1.4965	0.4322
14	Decision Tree	T=21	0.5231	185.49	0.4944	1.4694	0.4485
15	XGBoost	T=7	0.5587	220.47	0.5427	0.7138	0.4092
16	XGBoost	T=14	0.5282	201.32	0.4858	0.6766	0.4332
17	XGBoost	T=21	0.5133	197.87	0.4621	0.6595	0.4418

Parcial Práctico - Curso NLP¶

Ejercicio No. 1: Análisis Exploratorio de Datos¶

Dataset: Velocidad del Viento¶

a. Descripción de tipos de variables¶

b. Reducción de nombres extensos en columnas¶

c. Conteo de datos faltantes y su porcentaje¶

d. Calcular variables descriptivas¶

e. Histogramas & Diagramas de caja y bigotes¶

f. Análisis bivariado¶

Dataset: Detección de Fraude¶

a. Unir los datasets¶

b. Valores faltantes y tipos de variables¶

c. Análisis descriptivo¶

Identidad: Variables Numéricas¶

Transacción: Variables Categóricas¶

d. Eliminación e imputación de valores faltantes¶

Ejercicio No. 2. Modelos de Clasificiación¶

a. K-NN¶

b. Logistic Regression¶

c. Bayesian Classification¶

d. Decision Tree¶

e. Random Forest¶

f. XGBoost¶

g. Maquina de soporte vectorial - SVM***¶

h. Multi-Layer Perceptron - MLP¶

Resultados¶

Ejercicio No. 3. Modelos de Regresión¶

Particiones de tiempo¶

a. K-NN¶

b. Regresión Lineal¶

c. Modelo Ridge¶

d. Modelo Lasso¶

e. Arbol de decisión¶

f. Random Forest¶

g. XGBoost¶

h. SVM Regressor¶

i. Multi-Layer Perceptron¶

j. RNN¶

1. Crear secuencias de tiempo¶

2. Entrenamiento de la red neuronal¶

3. Evaluación de la Red Neuronal¶

k. Modelo LSTM¶

1. Crear secuencias de tiempo¶

2. Entrenamiento del modelo¶

3. Evaluación del modelo¶

Resultados¶